package com.lgmshare.component.utils;

import android.text.TextUtils;

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;

/**
 * 日期时间格式化工具
 *
 * @author: lim
 * @description: 日期时间格式化工具
 * @email: lgmshare@gmail.com
 * @datetime 2014-5-14 下午09:31:06
 */
public class DatetimeUtils {

    /**
     * 默认日期格式
     * **************************HH:mm    15:44
     * *************************h:mm a    3:44 下午
     * ************************HH:mm z    15:44 CST
     * ************************HH:mm Z    15:44 +0800
     * *********************HH:mm zzzz    15:44 中国标准时间
     * ***********************HH:mm:ss    15:44:40
     * *********************yyyy-MM-dd    2016-08-12
     * ***************yyyy-MM-dd HH:mm    2016-08-12 15:44
     * ************yyyy-MM-dd HH:mm:ss    2016-08-12 15:44:40
     * *******yyyy-MM-dd HH:mm:ss zzzz    2016-08-12 15:44:40 中国标准时间
     * **EEEE yyyy-MM-dd HH:mm:ss zzzz    星期五 2016-08-12 15:44:40 中国标准时间
     * *******yyyy-MM-dd HH:mm:ss.SSSZ    2016-08-12 15:44:40.461+0800
     * *****yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
     * ***yyyy.MM.dd G 'at' HH:mm:ss z    2016.08.12 公元 at 15:44:40 CST
     * *************************K:mm a    3:44 下午
     * ***************EEE, MMM d, ''yy    星期五, 八月 12, '16
     * **********hh 'o''clock' a, zzzz    03 o'clock 下午, 中国标准时间
     * ***yyyyy.MMMMM.dd GGG hh:mm aaa    02016.八月.12 公元 03:44 下午
     * *****EEE, d MMM yyyy HH:mm:ss Z    星期五, 12 八月 2016 15:44:40 +0800
     * ******************yyMMddHHmmssZ    160812154440+0800
     * *****yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
     * EEEE 'DATE('yyyy-MM-dd')' 'TIME('HH:mm:ss')' zzzz    星期五 DATE(2016-08-12) TIME(15:44:40) 中国标准时间
     */
    public static final String DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String MM = "mm";
    public static final String HH = "HH";
    public static final String HH_MM = "HH:mm";
    public static final String HH_MM_SS = "HH:mm:ss";
    public static final String YYYY_MM_DD = "yyyy-MM-dd";
    public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";
    public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    public static final String YYYYMMDD = "yyyyMMdd";
    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    public static final String YYYYMMDDHH_MM_SS = "yyyy/MM/dd HH:mm:ss";
    public static final String FORMAT_ALL = "yyyy-MM-dd HH:mm:ss.SSS";

    private DatetimeUtils() {
        //不能实例化
    }

    /**
     * 获取当前时间
     *
     * @return Date
     */
    public static Date getCurrentDate() {
        return new Date();
    }

    /**
     * 获取当前时间
     *
     * @return 返回短时间格式 yyyy-MM-dd
     */
    public static Date getCurrentDateShort() {
        Date currentTime = new Date();
        String sdate = format(currentTime, YYYY_MM_DD);
        return format(sdate, YYYY_MM_DD);
    }

    /**
     * 获取当前时间
     *
     * @return 返回时间类型 yyyy-MM-dd HH:mm:ss
     */
    public static Date getCurrentDateLong() {
        Date currentTime = new Date();
        String sdate = format(currentTime, YYYY_MM_DD_HH_MM_SS);
        return format(sdate, YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取当前时间 小时:分:秒 HH:mm:ss
     *
     * @return HH:mm:ss
     */
    public static String getCurrentTime() {
        Date currentTime = new Date();
        return format(currentTime, HH_MM_SS);
    }

    /**
     * 获取现在分钟
     *
     * @return
     */
    public static String getCurrentMinute() {
        Date currentTime = new Date();
        return format(currentTime, MM);
    }

    /**
     * 获取现在小时
     */
    public static String getCurrentHour() {
        Date currentTime = new Date();
        return format(currentTime, HH);
    }

    /**
     * 根据用户传入的时间表示格式，返回当前时间的格式 如果是yyyyMMdd，注意字母y不能大写。
     *
     * @param format 格式字符串 如：yyyyMMddhhmmss
     * @return
     */
    public static String getCurrentSdate(String format) {
        Date currentTime = new Date();
        return format(currentTime, format);
    }

    /**
     * 获取现在时间
     *
     * @return 返回短时间字符串格式 yyyy-MM-dd
     */
    public static String getCurrentSdateShort() {
        Date currentTime = new Date();
        return format(currentTime, YYYY_MM_DD);
    }

    /**
     * 获取现在时间
     *
     * @return 返回字符串格式 yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentSdateLong() {
        Date currentTime = new Date();
        return format(currentTime, YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获得当前时间戳
     *
     * @return long
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis();
    }

    /**
     * 时间前推或后推分钟,其中delay表示分钟.
     *
     * @param date  yyyy-MM-dd
     * @param delay
     * @return yyyy-MM-dd
     */
    public static Date getNextMinute(Date date, int delay) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.MINUTE, delay);
        return c.getTime();
    }

    /**
     * 时间前推或后推分钟,其中delay表示分钟.
     *
     * @param sdate  时间
     * @param format 传入时间格式
     * @param delay  delay为前移或后延的分钟数
     * @return
     */
    public static String getNextMinute(String sdate, String format, int delay) {
        Date cdate = format(sdate, format);
        Date ddate = getNextMinute(cdate, delay);
        return format(ddate, format);
    }

    /**
     * 得到一个时间延后或前移几天的时间,nowdate为时间,delay为前移或后延的天数
     *
     * @param date  yyyy-MM-dd
     * @param delay
     * @return yyyy-MM-dd
     */
    public static Date getNextDay(Date date, int delay) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.DAY_OF_MONTH, delay);
        return c.getTime();
    }

    /**
     * 得到一个时间延后或前移几天的时间,nowdate为时间,delay为前移或后延的天数
     *
     * @param sdate  时间
     * @param format 传入时间格式
     * @param delay
     * @return yyyy-MM-dd
     */
    public static String getNextDay(String sdate, String format, int delay) {
        Date cdate = format(sdate, format);
        Date ddate = getNextDay(cdate, delay);
        return format(ddate, format);
    }

    /**
     * 得到一个时间延后或前移几月的时间,nowdate为时间,delay为前移或后延的月数
     *
     * @param delay
     * @return
     */
    public static Date getNextMouth(Date date, int delay) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.MONTH, delay);
        return c.getTime();
    }

    /**
     * 得到一个时间延后或前移几月的时间,nowdate为时间,delay为前移或后延的月数
     *
     * @param sdate  时间
     * @param format 传入时间格式
     * @param delay
     * @return
     */
    public static String getNextMouth(String sdate, String format, int delay) {
        Date cdate = format(sdate, format);
        Date ddate = getNextMouth(cdate, delay);
        return format(ddate, format);
    }

    /**
     * 得到本月的第一天
     *
     * @return
     */
    public static String getMonthFirstDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
        return format(calendar.getTime(), YYYYMMDD);
    }

    /**
     * 得到本月的最后一天
     *
     * @return
     */
    public static String getMonthLastDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return format(calendar.getTime(), YYYYMMDD);
    }

    /**
     * 获取一个月的最后一天
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String getMonthLastDay(String sdate, String format) {
        Date date = format(sdate, format);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return format(calendar.getTime(), format);
    }

    /**
     * 产生周序列,即得到当前时间所在的年度是第几周
     *
     * @return
     */
    public static String getWeekSeq() {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        int week = calendar.get(Calendar.WEEK_OF_YEAR);
        if (week < 10) {
            return "0" + week;
        } else {
            return String.valueOf(week);
        }
    }

    /**
     * 产生周序列,即得到当前时间所在的年度是第几周
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String getWeekSeq(String sdate, String format) {
        Calendar calendar = Calendar.getInstance(Locale.CHINA);
        calendar.setTime(format(sdate, format));
        int week = calendar.get(Calendar.WEEK_OF_YEAR);
        if (week < 10) {
            return "0" + week;
        } else {
            return String.valueOf(week);
        }
    }

    /**
     * 根据一个日期，返回是星期几
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @return int 1=星期日 7=星期六，其他类推
     */
    public static int getWeek(String sdate, String format) {
        Calendar c = Calendar.getInstance();
        c.setTime(format(sdate, format));
        // 1=星期日 7=星期六，其他类推
        return c.get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 根据一个日期，返回是星期几的字符串
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String getWeekStr(String sdate, String format) {
        String str = "";
        int week = getWeek(sdate, format);
        if (1 == week) {
            str = "星期日";
        } else if (2 == week) {
            str = "星期一";
        } else if (3 == week) {
            str = "星期二";
        } else if (4 == week) {
            str = "星期三";
        } else if (5 == week) {
            str = "星期四";
        } else if (6 == week) {
            str = "星期五";
        } else if (7 == week) {
            str = "星期六";
        }
        return str;
    }

    /**
     * 根据一个日期，返回是星期几的字符串
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String getWeekStrFormat(String sdate, String format) {
        Calendar c = Calendar.getInstance();
        c.setTime(format(sdate, format));
        // 1=星期日 7=星期六，其他类推
        return format(c.getTime(), "EEEE");
    }

    /**
     * 获得一个日期所在的周的星期几的日期，如要找出2002年2月3日所在周的星期一是几号
     *
     * @param sdate  2017-12-20 18:07:12
     * @param format yyyy-MM-dd HH:mm:ss
     * @param num    所在周
     * @return
     */
    public static String getWeekOfDate(String sdate, String format, int num) {
        Calendar c = Calendar.getInstance();
        c.setTime(format(sdate, format));
        if (num == 1) {
            // 返回星期一所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        } else if (num == 2) {
            // 返回星期二所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
        } else if (num == 3) {
            // 返回星期三所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
        } else if (num == 4) {
            // 返回星期四所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
        } else if (num == 5) {
            // 返回星期五所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
        } else if (num == 6) {
            // 返回星期六所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
        } else if (num == 0) {
            // 返回星期日所在的日期
            c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        }
        if (getWeek(sdate, format) == 1) {
            return format(getNextDay(c.getTime(), -7), format);
        } else {
            return format(c.getTime(), format);
        }
    }

    /**
     * 获取某年中的某月的第一天是星期几
     *
     * @param year  目标年份
     * @param month 目标月份
     * @return
     */
    public static int getWeekDayOfMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(year, month - 1, 1);
        return cal.get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 获取指定日期所在周的开始及结束日期
     *
     * @param sdate  指定的日期  yyyy-MM-dd
     * @param format 指定的格式
     * @return String[0]:开始日期，String[1]:结束日期
     */
    public static String[] getWeekStartAndEndDate(String sdate, String format) {
        Date date = format(sdate, format);
        String[] dates = new String[2];
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        dates[0] = format(c.getTime(), format);
        c.add(Calendar.DATE, 6);
        dates[1] = format(c.getTime(), format);
        return dates;
    }

    /**
     * 两个时间之间相差的小时数
     *
     * @param date1
     * @param date2
     * @return
     */
    public static long getHoursDiff(Date date1, Date date2) {
        if (date1 == null) {
            return 0;
        }
        if (date2 == null) {
            return 0;
        }
        long hours = 0;
        try {
            hours = (date1.getTime() - date2.getTime()) / (60 * 60 * 1000);
        } catch (Exception e) {
            return hours;
        }
        return hours;
    }

    /**
     * 两个时间之间相差的小时数
     *
     * @param sdate1
     * @param sdate2
     * @param format 传入时间格式
     * @return
     */
    public static long getHoursDiff(String sdate1, String sdate2, String format) {
        if (sdate1 == null || "".equals(sdate1)) {
            return 0;
        }
        if (sdate2 == null || "".equals(sdate2)) {
            return 0;
        }
        long hours = 0;
        try {
            Date date1 = format(sdate1, format);
            Date date2 = format(sdate2, format);
            hours = (int) ((date1.getTime() - date2.getTime()) / (60 * 60 * 1000));
        } catch (Exception e) {
            return hours;
        }
        return hours;
    }

    /**
     * 两个时间之间相差的天数
     *
     * @param date1
     * @param date2
     * @return
     */
    public static int getDaysDiff(Date date1, Date date2) {
        if (date1 == null) {
            return 0;
        }
        if (date2 == null) {
            return 0;
        }
        int days = 0;
        try {
            days = (int) ((date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000));
        } catch (Exception e) {
            return days;
        }
        return days;
    }

    /**
     * 两个时间之间相差的天数
     *
     * @param sdate1
     * @param sdate2
     * @param format 传入时间格式
     * @return
     */
    public static int getDaysDiff(String sdate1, String sdate2, String format) {
        if (sdate1 == null || "".equals(sdate1)) {
            return 0;
        }
        if (sdate2 == null || "".equals(sdate2)) {
            return 0;
        }
        int days = 0;
        try {
            Date date1 = format(sdate1, format);
            Date date2 = format(sdate2, format);
            days = (int) ((date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000));
        } catch (Exception e) {
            return days;
        }
        return days;
    }

    /**
     * 计算时间差
     *
     * @param begin
     * @param end
     * @return 返回格式,"hh小时mm分钟ss秒"
     */
    public static String getTimeDiff(Date begin, Date end) {
        // 获得相差秒数
        long between = (end.getTime() - begin.getTime()) / 1000;
        long ss = between % 60;
        long mm = (between / 60) % 60;
        long hh = (between / 3600) % 24;
        long dd = between / (3600 * 24);

        StringBuffer time = new StringBuffer();
        if (dd != 0) {
            time.append(dd + "天");
        }
        if (hh != 0) {
            time.append(hh + "小时");
        }
        if (mm != 0) {
            time.append(mm + "分钟");
        }
        if (ss != 0 || dd != 0 || hh != 0 || mm != 0) {
            time.append(ss + "秒");
        }
        return time.toString();
    }

    /**
     * 计算时间差
     *
     * @param beginS
     * @param endS
     * @param format 传入时间格式
     * @return 返回格式,"hh小时mm分钟ss秒"
     * @throws ParseException
     */
    public static String getTimeDiff(String beginS, String endS, String format) {
        Date begin = format(beginS, format);
        Date end = format(endS, format);
        return getTimeDiff(begin, end);
    }

    /**
     * 返回该日历第一行星期日所在的日期
     * 形成如下20171220的日历根据传入的一个时间返回一个结构
     * 星期日 星期一 星期二 星期三 星期四 星期五 星期六
     * 26    27    28     29    30     1     2
     * 3     4     5      6     7      8     9
     * 10    11    12     13    14     15    16
     * ...
     * 31    1      2     3     4      5     6
     *
     * @param sdate
     * @param format
     * @return 返回20171126
     */
    public static String getMonthFirstDayForWeek(String sdate, String format) {
        // 得到这个月的1号是星期几
        Date date = format(sdate, format);
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        // 取该时间所在月的一号
        c.set(Calendar.DAY_OF_MONTH, 1);
        int u = c.get(Calendar.DAY_OF_WEEK);
        c.add(Calendar.DAY_OF_MONTH, (1 - u));
        return format(c.getTime(), format);
    }

    /**
     * 得到某月有多少天数
     *
     * @param isLeapYear 是否是闰年
     * @param month      目标月份
     * @return
     */
    public static int getDaysOfMonth(boolean isLeapYear, int month) {
        int daysOfMonth = 0;
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                daysOfMonth = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                daysOfMonth = 30;
                break;
            case 2:
                if (isLeapYear) {
                    daysOfMonth = 29;
                } else {
                    daysOfMonth = 28;
                }
                break;
            default:
                break;
        }
        return daysOfMonth;
    }

    /**
     * 判断给定字符串时间是否为今日
     *
     * @param sdate  时间字符串
     * @param format 传入的时间格式
     * @return boolean
     */
    public static boolean isToday(String sdate, String format) {
        boolean bl = false;
        Date today = getCurrentDate();
        Date time = format(sdate, format);
        if (time != null) {
            SimpleDateFormat sdf = new SimpleDateFormat(YYYYMMDD, Locale.getDefault());
            String nowDate = sdf.format(today);
            String timeDate = sdf.format(time);
            if (nowDate.equals(timeDate)) {
                bl = true;
            }
        }
        return bl;
    }

    /**
     * 判断是否润年
     *
     * @param sdate  时间字符串
     * @param format 传入的时间格式
     * @return
     */
    public static boolean isLeapYear(String sdate, String format) {
        /**
         * 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
         * 3.能被4整除同时能被100整除则不是闰年
         */
        Date date = format(sdate, format);
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        int year = gc.get(Calendar.YEAR);
        if ((year % 400) == 0) {
            return true;
        } else {
            return (year % 4) == 0 && (year % 100) != 0;
        }
    }

    /**
     * 判断二个时间是否在同一个周
     *
     * @param date1
     * @param date2
     * @return
     */
    public static boolean isSameWeek(Date date1, Date date2) {
        Calendar cal1 = Calendar.getInstance();
        Calendar cal2 = Calendar.getInstance();
        cal1.setTime(date1);
        cal2.setTime(date2);
        int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
        if (0 == subYear) {
            return cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR);
        } else if (1 == subYear && Calendar.DECEMBER == cal2.get(Calendar.MONTH)) {
            // 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
            return cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR);
        } else if (-1 == subYear && Calendar.DECEMBER == cal1.get(Calendar.MONTH)) {
            return cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR);
        }
        return false;
    }

    /**
     * 时间字符串格式化
     *
     * @param date   时间
     * @param format 输出的时间格式
     * @return
     */
    public static String format(Date date, String format) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat strFormat = new SimpleDateFormat(format, Locale.getDefault());
        return strFormat.format(date);
    }

    /**
     * 时间字符串格式化
     *
     * @param sdate  时间
     * @param format 传入的时间格式
     * @return
     */
    public static Date format(String sdate, String format) {
        if (sdate == null) {
            return null;
        }
        SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.getDefault());
        ParsePosition pos = new ParsePosition(0);
        return formatter.parse(sdate, pos);
    }

    /**
     * 时间字符串格式化
     *
     * @param sdate   时间
     * @param format1 传入的时间格式
     * @param format2 传出的时间格式
     * @return
     */
    public static String format(String sdate, String format1, String format2) {
        if (sdate == null) {
            return null;
        }
        SimpleDateFormat formatter = new SimpleDateFormat(format1, Locale.getDefault());
        ParsePosition pos = new ParsePosition(0);
        return format(formatter.parse(sdate, pos), format2);
    }

    /**
     * 对时间戳格式进行格式化，保证时间戳长度为13位
     *
     * @param timestamp 时间戳
     * @return 返回为13位的时间戳
     */
    public static long formatTimestamp(String timestamp) {
        if (timestamp == null || "".equals(timestamp)) {
            return 0;
        }
        String tempTimeStamp = timestamp + "00000000000000";
        StringBuffer stringBuffer = new StringBuffer(tempTimeStamp);
        return StringUtils.parseLong(stringBuffer.substring(0, 13));
    }

    /**
     * 日期格式转时间戳
     *
     * @param sdate  时间字符串
     * @param format 传入的时间格式
     * @return
     */
    public static long formatSdateToTimestamp(String sdate, String format) {
        Date date = format(sdate, format);
        if (date == null) {
            return 0;
        }
        return date.getTime();
    }

    /**
     * 时间戳转日期格式
     *
     * @param timestamp 时间戳
     * @return
     */
    public static Date formatTimestampToDate(String timestamp) {
        if (TextUtils.isEmpty(timestamp)) {
            return null;
        }
        return new Date(formatTimestamp(timestamp));
    }

    /**
     * 时间戳转日期格式
     *
     * @param timestamp 时间戳
     * @return
     */
    public static Date formatTimestampToDate(long timestamp) {
        return new Date(timestamp);
    }

    /**
     * 时间戳转日期格式
     *
     * @param timestamp 时间戳
     * @param format    需要返回的日期格式
     * @return
     */
    public static String formatTimestampToSdate(long timestamp, String format) {
        if (timestamp == 0) {
            return "";
        }
        return format(formatTimestampToDate(timestamp), format);
    }

    /**
     * 时间戳转日期格式
     *
     * @param timestamp 时间戳
     * @param format    需要返回的日期格式
     * @return
     */
    public static String formatTimestampToSdate(String timestamp, String format) {
        if (TextUtils.isEmpty(timestamp)) {
            return "";
        }
        return format(formatTimestampToDate(timestamp), format);
    }

    /**
     * 以友好的方式显示日期
     *
     * @param sdate  时间字符串
     * @param format 传入的时间格式
     * @return
     */
    public static String friendlyTime(String sdate, String format) {
        Date date = format(sdate, format);
        if (date == null) {
            return "Unknown";
        }
        String time = "";
        SimpleDateFormat sdf = new SimpleDateFormat(YYYYMMDD, Locale.getDefault());
        Calendar calendar = Calendar.getInstance();
        // 判断是否是同一天
        String cDate = sdf.format(calendar.getTime());
        String tDate = sdf.format(date);
        if (cDate.equals(tDate)) {
            return "今天";
        }
        long lt = date.getTime() / 86400000;
        long ct = calendar.getTimeInMillis() / 86400000;
        int days = (int) (ct - lt);
        if (days < -2) {
            time = sdf.format(date);
        } else if (days == -2) {
            time = "后天";
        } else if (days == -1) {
            time = "明天";
        } else if (days == 0) {
            int hour = (int) ((calendar.getTimeInMillis() - date.getTime()) / 3600000);
            if (hour == 0) {
                time = Math.max((calendar.getTimeInMillis() - date.getTime()) / 60000, 1) + "分钟前";
            } else {
                time = hour + "小时前";
            }
        } else if (days == 1) {
            time = "昨天";
        } else if (days == 2) {
            time = "前天";
        } else if (days > 2 && days <= 10) {
            time = days + "天前";
        } else if (days > 10) {
            time = sdf.format(date);
        }
        return time;
    }

    /**
     * 将时间戳以友好的方式显示，根据 timestamp 生成各类时间状态串
     *
     * @param timestamp 距1970 00:00:00 GMT的秒数
     * @return 时间状态串(如 ： 刚刚5分钟前)
     */
    public static String friendlyTimestamp(String timestamp) {
        if (timestamp == null || "".equals(timestamp)) {
            return "Unknown";
        }
        long tt = formatTimestamp(timestamp);
        long st = getCurrentTimestamp();
        if (st - tt < 60 * 1000) {
            return "刚刚";
        } else if (st - tt < 30 * 60 * 1000) {
            return ((st - tt) / 1000 / 60) + "分钟前";
        } else {
            SimpleDateFormat sdf = null;
            Calendar now = Calendar.getInstance();
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(tt);
            if (c.get(Calendar.YEAR) == now.get(Calendar.YEAR)
                    && c.get(Calendar.MONTH) == now.get(Calendar.MONTH)
                    && c.get(Calendar.DATE) == now.get(Calendar.DATE)) {
                sdf = new SimpleDateFormat("今天 HH:mm", Locale.getDefault());
                return sdf.format(c.getTime());
            }
            if (c.get(Calendar.YEAR) == now.get(Calendar.YEAR)
                    && c.get(Calendar.MONTH) == now.get(Calendar.MONTH)
                    && c.get(Calendar.DATE) == now.get(Calendar.DATE) - 1) {
                sdf = new SimpleDateFormat("昨天 HH:mm", Locale.getDefault());
                return sdf.format(c.getTime());
            } else if (c.get(Calendar.YEAR) == now.get(Calendar.YEAR)) {
                sdf = new SimpleDateFormat("M月d日 HH:mm", Locale.getDefault());
                return sdf.format(c.getTime());
            } else {
                sdf = new SimpleDateFormat("yyyy年M月d日 HH:mm", Locale.getDefault());
                return sdf.format(c.getTime());
            }
        }
    }
}